// $ANTLR 2.7.5 (20050128): "shoiq.g" -> "FormulaParser.java"$

  package com.googlecode.kipler.parsing;
  import com.googlecode.kipler.*;
import com.googlecode.kipler.container.dl.*;
  import com.googlecode.kipler.satisfiability.*;
  import com.googlecode.kipler.syntax.*;
  import com.googlecode.kipler.syntax.formula.*;
  import com.googlecode.kipler.syntax.concept.*;
  import java.util.*;

import antlr.TokenBuffer;
import antlr.TokenStreamException;
import antlr.TokenStreamIOException;
import antlr.ANTLRException;
import antlr.LLkParser;
import antlr.Token;
import antlr.TokenStream;
import antlr.RecognitionException;
import antlr.NoViableAltException;
import antlr.MismatchedTokenException;
import antlr.SemanticException;
import antlr.ParserSharedInputState;
import antlr.collections.impl.BitSet;
import antlr.collections.AST;
import java.util.Hashtable;
import antlr.ASTFactory;
import antlr.ASTPair;
import antlr.collections.impl.ASTArray;

public class FormulaParser extends antlr.LLkParser       implements FormulaParserTokenTypes
 {

protected FormulaParser(TokenBuffer tokenBuf, int k) {
  super(tokenBuf,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

public FormulaParser(TokenBuffer tokenBuf) {
  this(tokenBuf,5);
}

protected FormulaParser(TokenStream lexer, int k) {
  super(lexer,k);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

public FormulaParser(TokenStream lexer) {
  this(lexer,5);
}

public FormulaParser(ParserSharedInputState state) {
  super(state,5);
  tokenNames = _tokenNames;
  buildTokenTypeASTClassMap();
  astFactory = new ASTFactory(getTokenTypeToASTClassMap());
}

	public final void world() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST world_AST = null;
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case NAMESPACE:
			{
				namespaceArea();
				astFactory.addASTChild(currentAST, returnAST);
				break;
			}
			case LPAREN:
			case NCName:
			case NEXT:
			case SOMETIME:
			case GENERALLY:
			case NOT:
			case TRANSITIVE:
			case AND:
			case OR:
			case TILDE:
			case SOME:
			case ALL:
			case GREATER_THAN_OR_EQ:
			case LESS_THAN_OR_EQ:
			case LBRACE:
			case DASH:
			case QNAME:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			semiColSeparatedFormula();
			astFactory.addASTChild(currentAST, returnAST);
			if ( inputState.guessing==0 ) {
				world_AST = (AST)currentAST.root;
				world_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(WORLD)).add(world_AST));
				currentAST.root = world_AST;
				currentAST.child = world_AST!=null &&world_AST.getFirstChild()!=null ?
					world_AST.getFirstChild() : world_AST;
				currentAST.advanceChildToEnd();
			}
			world_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_0);
			} else {
			  throw ex;
			}
		}
		returnAST = world_AST;
	}
	
	public final void namespaceArea() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST namespaceArea_AST = null;
		
		try {      // for error handling
			namespace();
			astFactory.addASTChild(currentAST, returnAST);
			{
			_loop8:
			do {
				if ((LA(1)==SEMICOLON) && (LA(2)==NAMESPACE)) {
					AST tmp1_AST = null;
					tmp1_AST = astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp1_AST);
					match(SEMICOLON);
					namespace();
					astFactory.addASTChild(currentAST, returnAST);
				}
				else {
					break _loop8;
				}
				
			} while (true);
			}
			match(SEMICOLON);
			namespaceArea_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_1);
			} else {
			  throw ex;
			}
		}
		returnAST = namespaceArea_AST;
	}
	
	public final void semiColSeparatedFormula() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST semiColSeparatedFormula_AST = null;
		
		try {      // for error handling
			formula();
			astFactory.addASTChild(currentAST, returnAST);
			{
			_loop5:
			do {
				if ((LA(1)==SEMICOLON) && (_tokenSet_1.member(LA(2)))) {
					AST tmp3_AST = null;
					tmp3_AST = astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp3_AST);
					match(SEMICOLON);
					formula();
					astFactory.addASTChild(currentAST, returnAST);
				}
				else {
					break _loop5;
				}
				
			} while (true);
			}
			match(SEMICOLON);
			semiColSeparatedFormula_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_0);
			} else {
			  throw ex;
			}
		}
		returnAST = semiColSeparatedFormula_AST;
	}
	
	public final void formula() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST formula_AST = null;
		
		try {      // for error handling
			boolean synPredMatched13 = false;
			if (((LA(1)==LPAREN) && (_tokenSet_1.member(LA(2))) && (_tokenSet_2.member(LA(3))) && (_tokenSet_3.member(LA(4))) && (_tokenSet_4.member(LA(5))))) {
				int _m13 = mark();
				synPredMatched13 = true;
				inputState.guessing++;
				try {
					{
					match(LPAREN);
					formula1();
					}
				}
				catch (RecognitionException pe) {
					synPredMatched13 = false;
				}
				rewind(_m13);
				inputState.guessing--;
			}
			if ( synPredMatched13 ) {
				match(LPAREN);
				formula1();
				astFactory.addASTChild(currentAST, returnAST);
				match(RPAREN);
				{
				int _cnt16=0;
				_loop16:
				do {
					if ((LA(1)==UNTIL||LA(1)==BEFORE)) {
						{
						switch ( LA(1)) {
						case UNTIL:
						{
							AST tmp7_AST = null;
							tmp7_AST = astFactory.create(LT(1));
							astFactory.makeASTRoot(currentAST, tmp7_AST);
							match(UNTIL);
							break;
						}
						case BEFORE:
						{
							AST tmp8_AST = null;
							tmp8_AST = astFactory.create(LT(1));
							astFactory.makeASTRoot(currentAST, tmp8_AST);
							match(BEFORE);
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						}
						}
						match(LPAREN);
						formula1();
						astFactory.addASTChild(currentAST, returnAST);
						match(RPAREN);
					}
					else {
						if ( _cnt16>=1 ) { break _loop16; } else {throw new NoViableAltException(LT(1), getFilename());}
					}
					
					_cnt16++;
				} while (true);
				}
				formula_AST = (AST)currentAST.root;
			}
			else if ((_tokenSet_1.member(LA(1))) && (_tokenSet_2.member(LA(2))) && (_tokenSet_3.member(LA(3))) && (_tokenSet_5.member(LA(4))) && (_tokenSet_5.member(LA(5)))) {
				formula1();
				astFactory.addASTChild(currentAST, returnAST);
				formula_AST = (AST)currentAST.root;
			}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = formula_AST;
	}
	
	public final void namespace() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST namespace_AST = null;
		
		try {      // for error handling
			AST tmp11_AST = null;
			tmp11_AST = astFactory.create(LT(1));
			astFactory.makeASTRoot(currentAST, tmp11_AST);
			match(NAMESPACE);
			match(LPAREN);
			AST tmp13_AST = null;
			tmp13_AST = astFactory.create(LT(1));
			astFactory.addASTChild(currentAST, tmp13_AST);
			match(PREFIX);
			match(COLON);
			AST tmp15_AST = null;
			tmp15_AST = astFactory.create(LT(1));
			astFactory.addASTChild(currentAST, tmp15_AST);
			match(NCName);
			match(RPAREN);
			namespace_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_7);
			} else {
			  throw ex;
			}
		}
		returnAST = namespace_AST;
	}
	
	public final void formulaWithNs() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST formulaWithNs_AST = null;
		
		try {      // for error handling
			namespaceArea();
			astFactory.addASTChild(currentAST, returnAST);
			formula();
			astFactory.addASTChild(currentAST, returnAST);
			formulaWithNs_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_0);
			} else {
			  throw ex;
			}
		}
		returnAST = formulaWithNs_AST;
	}
	
	public final void formula1() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST formula1_AST = null;
		
		try {      // for error handling
			switch ( LA(1)) {
			case AND:
			case OR:
			{
				booleanFormula();
				astFactory.addASTChild(currentAST, returnAST);
				formula1_AST = (AST)currentAST.root;
				break;
			}
			case NOT:
			{
				negFormula();
				astFactory.addASTChild(currentAST, returnAST);
				formula1_AST = (AST)currentAST.root;
				break;
			}
			default:
				boolean synPredMatched20 = false;
				if ((((LA(1) >= NEXT && LA(1) <= GENERALLY)) && (LA(2)==LPAREN) && (_tokenSet_1.member(LA(3))) && (_tokenSet_8.member(LA(4))) && (_tokenSet_9.member(LA(5))))) {
					int _m20 = mark();
					synPredMatched20 = true;
					inputState.guessing++;
					try {
						{
						{
						switch ( LA(1)) {
						case NEXT:
						{
							match(NEXT);
							break;
						}
						case SOMETIME:
						{
							match(SOMETIME);
							break;
						}
						case GENERALLY:
						{
							match(GENERALLY);
							break;
						}
						default:
						{
							throw new NoViableAltException(LT(1), getFilename());
						}
						}
						}
						match(LPAREN);
						formula();
						}
					}
					catch (RecognitionException pe) {
						synPredMatched20 = false;
					}
					rewind(_m20);
					inputState.guessing--;
				}
				if ( synPredMatched20 ) {
					unaryLTLFormula();
					astFactory.addASTChild(currentAST, returnAST);
					formula1_AST = (AST)currentAST.root;
				}
				else if ((_tokenSet_10.member(LA(1))) && (_tokenSet_2.member(LA(2))) && (_tokenSet_11.member(LA(3))) && (_tokenSet_12.member(LA(4))) && (_tokenSet_13.member(LA(5)))) {
					dlFormula();
					astFactory.addASTChild(currentAST, returnAST);
					formula1_AST = (AST)currentAST.root;
				}
			else {
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = formula1_AST;
	}
	
	public final void unaryLTLFormula() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST unaryLTLFormula_AST = null;
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case NEXT:
			{
				AST tmp17_AST = null;
				tmp17_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp17_AST);
				match(NEXT);
				break;
			}
			case SOMETIME:
			{
				AST tmp18_AST = null;
				tmp18_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp18_AST);
				match(SOMETIME);
				break;
			}
			case GENERALLY:
			{
				AST tmp19_AST = null;
				tmp19_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp19_AST);
				match(GENERALLY);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			match(LPAREN);
			formula();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			unaryLTLFormula_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = unaryLTLFormula_AST;
	}
	
	public final void dlFormula() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST dlFormula_AST = null;
		
		try {      // for error handling
			boolean synPredMatched24 = false;
			if (((LA(1)==NCName||LA(1)==DASH||LA(1)==QNAME) && (LA(2)==LPAREN||LA(2)==IMPLIES_ROLE) && (LA(3)==NCName||LA(3)==DASH||LA(3)==QNAME) && (_tokenSet_14.member(LA(4))) && (_tokenSet_15.member(LA(5))))) {
				int _m24 = mark();
				synPredMatched24 = true;
				inputState.guessing++;
				try {
					{
					role();
					match(IMPLIES_ROLE);
					}
				}
				catch (RecognitionException pe) {
					synPredMatched24 = false;
				}
				rewind(_m24);
				inputState.guessing--;
			}
			if ( synPredMatched24 ) {
				roleInclusion();
				astFactory.addASTChild(currentAST, returnAST);
				dlFormula_AST = (AST)currentAST.root;
			}
			else {
				boolean synPredMatched26 = false;
				if (((LA(1)==NCName||LA(1)==DASH||LA(1)==QNAME) && (LA(2)==LPAREN) && (LA(3)==NCName||LA(3)==QNAME) && (LA(4)==RPAREN||LA(4)==COMMA) && (LA(5)==LPAREN||LA(5)==NCName||LA(5)==QNAME))) {
					int _m26 = mark();
					synPredMatched26 = true;
					inputState.guessing++;
					try {
						{
						role();
						match(LPAREN);
						uriReference();
						match(COMMA);
						}
					}
					catch (RecognitionException pe) {
						synPredMatched26 = false;
					}
					rewind(_m26);
					inputState.guessing--;
				}
				if ( synPredMatched26 ) {
					objectRoleAssertion();
					astFactory.addASTChild(currentAST, returnAST);
					dlFormula_AST = (AST)currentAST.root;
				}
				else {
					boolean synPredMatched29 = false;
					if (((_tokenSet_16.member(LA(1))) && (_tokenSet_17.member(LA(2))) && (_tokenSet_11.member(LA(3))) && (_tokenSet_12.member(LA(4))) && (_tokenSet_18.member(LA(5))))) {
						int _m29 = mark();
						synPredMatched29 = true;
						inputState.guessing++;
						try {
							{
							concept();
							{
							switch ( LA(1)) {
							case EQUALS:
							{
								match(EQUALS);
								break;
							}
							case IMPLIES:
							{
								match(IMPLIES);
								break;
							}
							default:
							{
								throw new NoViableAltException(LT(1), getFilename());
							}
							}
							}
							}
						}
						catch (RecognitionException pe) {
							synPredMatched29 = false;
						}
						rewind(_m29);
						inputState.guessing--;
					}
					if ( synPredMatched29 ) {
						conceptDefinition();
						astFactory.addASTChild(currentAST, returnAST);
						dlFormula_AST = (AST)currentAST.root;
					}
					else if ((LA(1)==TRANSITIVE)) {
						roleAssertion();
						astFactory.addASTChild(currentAST, returnAST);
						dlFormula_AST = (AST)currentAST.root;
					}
					else if ((_tokenSet_16.member(LA(1))) && (_tokenSet_19.member(LA(2))) && (_tokenSet_20.member(LA(3))) && (_tokenSet_21.member(LA(4))) && (_tokenSet_22.member(LA(5)))) {
						conceptAssertion();
						astFactory.addASTChild(currentAST, returnAST);
						dlFormula_AST = (AST)currentAST.root;
					}
					else if ((LA(1)==NCName||LA(1)==QNAME) && (LA(2)==DOUBLE_EQUAL)) {
						sameIndividualAssertion();
						astFactory.addASTChild(currentAST, returnAST);
						dlFormula_AST = (AST)currentAST.root;
					}
					else {
						throw new NoViableAltException(LT(1), getFilename());
					}
					}}
				}
				catch (RecognitionException ex) {
					if (inputState.guessing==0) {
						reportError(ex);
						recover(ex,_tokenSet_6);
					} else {
					  throw ex;
					}
				}
				returnAST = dlFormula_AST;
			}
			
	public final void booleanFormula() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST booleanFormula_AST = null;
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case AND:
			{
				AST tmp22_AST = null;
				tmp22_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp22_AST);
				match(AND);
				break;
			}
			case OR:
			{
				AST tmp23_AST = null;
				tmp23_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp23_AST);
				match(OR);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			match(LPAREN);
			formula();
			astFactory.addASTChild(currentAST, returnAST);
			match(COMMA);
			commaSeparatedFormula();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			booleanFormula_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = booleanFormula_AST;
	}
	
	public final void negFormula() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST negFormula_AST = null;
		
		try {      // for error handling
			AST tmp27_AST = null;
			tmp27_AST = astFactory.create(LT(1));
			astFactory.makeASTRoot(currentAST, tmp27_AST);
			match(NOT);
			match(LPAREN);
			formula();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			negFormula_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = negFormula_AST;
	}
	
	public final void role() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST role_AST = null;
		
		try {      // for error handling
			switch ( LA(1)) {
			case NCName:
			case QNAME:
			{
				uriReference();
				astFactory.addASTChild(currentAST, returnAST);
				role_AST = (AST)currentAST.root;
				break;
			}
			case DASH:
			{
				AST tmp30_AST = null;
				tmp30_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp30_AST);
				match(DASH);
				match(LPAREN);
				uriReference();
				astFactory.addASTChild(currentAST, returnAST);
				match(RPAREN);
				role_AST = (AST)currentAST.root;
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_23);
			} else {
			  throw ex;
			}
		}
		returnAST = role_AST;
	}
	
	public final void roleInclusion() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST roleInclusion_AST = null;
		
		try {      // for error handling
			role();
			astFactory.addASTChild(currentAST, returnAST);
			AST tmp33_AST = null;
			tmp33_AST = astFactory.create(LT(1));
			astFactory.makeASTRoot(currentAST, tmp33_AST);
			match(IMPLIES_ROLE);
			role();
			astFactory.addASTChild(currentAST, returnAST);
			roleInclusion_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = roleInclusion_AST;
	}
	
	public final void uriReference() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST uriReference_AST = null;
		
		try {      // for error handling
			switch ( LA(1)) {
			case NCName:
			{
				AST tmp34_AST = null;
				tmp34_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentAST, tmp34_AST);
				match(NCName);
				uriReference_AST = (AST)currentAST.root;
				break;
			}
			case QNAME:
			{
				AST tmp35_AST = null;
				tmp35_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentAST, tmp35_AST);
				match(QNAME);
				uriReference_AST = (AST)currentAST.root;
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_24);
			} else {
			  throw ex;
			}
		}
		returnAST = uriReference_AST;
	}
	
	public final void objectRoleAssertion() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST objectRoleAssertion_AST = null;
		
		try {      // for error handling
			role();
			astFactory.addASTChild(currentAST, returnAST);
			match(LPAREN);
			uriReference();
			astFactory.addASTChild(currentAST, returnAST);
			match(COMMA);
			uriReference();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			if ( inputState.guessing==0 ) {
				objectRoleAssertion_AST = (AST)currentAST.root;
				objectRoleAssertion_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(OBJECT_ROLE_ASSERTION)).add(objectRoleAssertion_AST));
				currentAST.root = objectRoleAssertion_AST;
				currentAST.child = objectRoleAssertion_AST!=null &&objectRoleAssertion_AST.getFirstChild()!=null ?
					objectRoleAssertion_AST.getFirstChild() : objectRoleAssertion_AST;
				currentAST.advanceChildToEnd();
			}
			objectRoleAssertion_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = objectRoleAssertion_AST;
	}
	
	public final void concept() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST concept_AST = null;
		
		try {      // for error handling
			concept1();
			astFactory.addASTChild(currentAST, returnAST);
			{
			_loop47:
			do {
				if ((LA(1)==UNTIL||LA(1)==BEFORE||LA(1)==BAR)) {
					{
					switch ( LA(1)) {
					case BAR:
					{
						AST tmp39_AST = null;
						tmp39_AST = astFactory.create(LT(1));
						astFactory.makeASTRoot(currentAST, tmp39_AST);
						match(BAR);
						break;
					}
					case UNTIL:
					{
						AST tmp40_AST = null;
						tmp40_AST = astFactory.create(LT(1));
						astFactory.makeASTRoot(currentAST, tmp40_AST);
						match(UNTIL);
						break;
					}
					case BEFORE:
					{
						AST tmp41_AST = null;
						tmp41_AST = astFactory.create(LT(1));
						astFactory.makeASTRoot(currentAST, tmp41_AST);
						match(BEFORE);
						break;
					}
					default:
					{
						throw new NoViableAltException(LT(1), getFilename());
					}
					}
					}
					concept1();
					astFactory.addASTChild(currentAST, returnAST);
				}
				else {
					break _loop47;
				}
				
			} while (true);
			}
			concept_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_25);
			} else {
			  throw ex;
			}
		}
		returnAST = concept_AST;
	}
	
	public final void conceptDefinition() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST conceptDefinition_AST = null;
		
		try {      // for error handling
			concept();
			astFactory.addASTChild(currentAST, returnAST);
			{
			switch ( LA(1)) {
			case EQUALS:
			{
				AST tmp42_AST = null;
				tmp42_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp42_AST);
				match(EQUALS);
				break;
			}
			case IMPLIES:
			{
				AST tmp43_AST = null;
				tmp43_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp43_AST);
				match(IMPLIES);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			concept();
			astFactory.addASTChild(currentAST, returnAST);
			conceptDefinition_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = conceptDefinition_AST;
	}
	
	public final void roleAssertion() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST roleAssertion_AST = null;
		
		try {      // for error handling
			AST tmp44_AST = null;
			tmp44_AST = astFactory.create(LT(1));
			astFactory.makeASTRoot(currentAST, tmp44_AST);
			match(TRANSITIVE);
			match(LPAREN);
			role();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			roleAssertion_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = roleAssertion_AST;
	}
	
	public final void conceptAssertion() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST conceptAssertion_AST = null;
		
		try {      // for error handling
			concept();
			astFactory.addASTChild(currentAST, returnAST);
			match(LPAREN);
			uriReference();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			if ( inputState.guessing==0 ) {
				conceptAssertion_AST = (AST)currentAST.root;
				conceptAssertion_AST = (AST)astFactory.make( (new ASTArray(2)).add(astFactory.create(CONCEPT_ASSERTION)).add(conceptAssertion_AST));
				currentAST.root = conceptAssertion_AST;
				currentAST.child = conceptAssertion_AST!=null &&conceptAssertion_AST.getFirstChild()!=null ?
					conceptAssertion_AST.getFirstChild() : conceptAssertion_AST;
				currentAST.advanceChildToEnd();
			}
			conceptAssertion_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = conceptAssertion_AST;
	}
	
	public final void sameIndividualAssertion() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST sameIndividualAssertion_AST = null;
		
		try {      // for error handling
			uriReference();
			astFactory.addASTChild(currentAST, returnAST);
			AST tmp49_AST = null;
			tmp49_AST = astFactory.create(LT(1));
			astFactory.makeASTRoot(currentAST, tmp49_AST);
			match(DOUBLE_EQUAL);
			uriReference();
			astFactory.addASTChild(currentAST, returnAST);
			sameIndividualAssertion_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_6);
			} else {
			  throw ex;
			}
		}
		returnAST = sameIndividualAssertion_AST;
	}
	
	public final void commaSeparatedFormula() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST commaSeparatedFormula_AST = null;
		
		try {      // for error handling
			formula();
			astFactory.addASTChild(currentAST, returnAST);
			{
			_loop41:
			do {
				if ((LA(1)==COMMA)) {
					AST tmp50_AST = null;
					tmp50_AST = astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp50_AST);
					match(COMMA);
					formula();
					astFactory.addASTChild(currentAST, returnAST);
				}
				else {
					break _loop41;
				}
				
			} while (true);
			}
			commaSeparatedFormula_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_26);
			} else {
			  throw ex;
			}
		}
		returnAST = commaSeparatedFormula_AST;
	}
	
	public final void concept1() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST concept1_AST = null;
		
		try {      // for error handling
			concept2();
			astFactory.addASTChild(currentAST, returnAST);
			{
			_loop50:
			do {
				if ((LA(1)==AMP)) {
					AST tmp51_AST = null;
					tmp51_AST = astFactory.create(LT(1));
					astFactory.makeASTRoot(currentAST, tmp51_AST);
					match(AMP);
					concept2();
					astFactory.addASTChild(currentAST, returnAST);
				}
				else {
					break _loop50;
				}
				
			} while (true);
			}
			concept1_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_27);
			} else {
			  throw ex;
			}
		}
		returnAST = concept1_AST;
	}
	
	public final void concept2() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST concept2_AST = null;
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case TILDE:
			{
				AST tmp52_AST = null;
				tmp52_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp52_AST);
				match(TILDE);
				break;
			}
			case LPAREN:
			case NCName:
			case NEXT:
			case SOMETIME:
			case GENERALLY:
			case SOME:
			case ALL:
			case GREATER_THAN_OR_EQ:
			case LESS_THAN_OR_EQ:
			case LBRACE:
			case QNAME:
			{
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			{
			switch ( LA(1)) {
			case NCName:
			case QNAME:
			{
				atomicConcept();
				astFactory.addASTChild(currentAST, returnAST);
				break;
			}
			case LPAREN:
			{
				generalizedConcept();
				astFactory.addASTChild(currentAST, returnAST);
				break;
			}
			case SOME:
			case ALL:
			{
				roleQuantification();
				astFactory.addASTChild(currentAST, returnAST);
				break;
			}
			case GREATER_THAN_OR_EQ:
			case LESS_THAN_OR_EQ:
			{
				qualifiedNoRestriction();
				astFactory.addASTChild(currentAST, returnAST);
				break;
			}
			case LBRACE:
			{
				nominal();
				astFactory.addASTChild(currentAST, returnAST);
				break;
			}
			case NEXT:
			case SOMETIME:
			case GENERALLY:
			{
				unaryLTLConcept();
				astFactory.addASTChild(currentAST, returnAST);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			concept2_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
		returnAST = concept2_AST;
	}
	
	public final void atomicConcept() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST atomicConcept_AST = null;
		
		try {      // for error handling
			uriReference();
			astFactory.addASTChild(currentAST, returnAST);
			atomicConcept_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
		returnAST = atomicConcept_AST;
	}
	
	public final void generalizedConcept() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST generalizedConcept_AST = null;
		
		try {      // for error handling
			match(LPAREN);
			concept();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			generalizedConcept_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
		returnAST = generalizedConcept_AST;
	}
	
	public final void roleQuantification() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST roleQuantification_AST = null;
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case SOME:
			{
				AST tmp55_AST = null;
				tmp55_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp55_AST);
				match(SOME);
				break;
			}
			case ALL:
			{
				AST tmp56_AST = null;
				tmp56_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp56_AST);
				match(ALL);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			match(LPAREN);
			role();
			astFactory.addASTChild(currentAST, returnAST);
			match(COMMA);
			concept();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			roleQuantification_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
		returnAST = roleQuantification_AST;
	}
	
	public final void qualifiedNoRestriction() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST qualifiedNoRestriction_AST = null;
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case GREATER_THAN_OR_EQ:
			{
				AST tmp60_AST = null;
				tmp60_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp60_AST);
				match(GREATER_THAN_OR_EQ);
				break;
			}
			case LESS_THAN_OR_EQ:
			{
				AST tmp61_AST = null;
				tmp61_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp61_AST);
				match(LESS_THAN_OR_EQ);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			match(LPAREN);
			unsignedInt();
			astFactory.addASTChild(currentAST, returnAST);
			match(COMMA);
			role();
			astFactory.addASTChild(currentAST, returnAST);
			match(COMMA);
			concept();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			qualifiedNoRestriction_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
		returnAST = qualifiedNoRestriction_AST;
	}
	
	public final void nominal() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST nominal_AST = null;
		
		try {      // for error handling
			AST tmp66_AST = null;
			tmp66_AST = astFactory.create(LT(1));
			astFactory.makeASTRoot(currentAST, tmp66_AST);
			match(LBRACE);
			uriReference();
			astFactory.addASTChild(currentAST, returnAST);
			match(RBRACE);
			nominal_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
		returnAST = nominal_AST;
	}
	
	public final void unaryLTLConcept() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST unaryLTLConcept_AST = null;
		
		try {      // for error handling
			{
			switch ( LA(1)) {
			case NEXT:
			{
				AST tmp68_AST = null;
				tmp68_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp68_AST);
				match(NEXT);
				break;
			}
			case SOMETIME:
			{
				AST tmp69_AST = null;
				tmp69_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp69_AST);
				match(SOMETIME);
				break;
			}
			case GENERALLY:
			{
				AST tmp70_AST = null;
				tmp70_AST = astFactory.create(LT(1));
				astFactory.makeASTRoot(currentAST, tmp70_AST);
				match(GENERALLY);
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
			}
			match(LPAREN);
			concept();
			astFactory.addASTChild(currentAST, returnAST);
			match(RPAREN);
			unaryLTLConcept_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_28);
			} else {
			  throw ex;
			}
		}
		returnAST = unaryLTLConcept_AST;
	}
	
	public final void unsignedInt() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST unsignedInt_AST = null;
		
		try {      // for error handling
			AST tmp73_AST = null;
			tmp73_AST = astFactory.create(LT(1));
			astFactory.addASTChild(currentAST, tmp73_AST);
			match(UNSIGNED_INT);
			unsignedInt_AST = (AST)currentAST.root;
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_29);
			} else {
			  throw ex;
			}
		}
		returnAST = unsignedInt_AST;
	}
	
	public final void term() throws RecognitionException, TokenStreamException {
		
		returnAST = null;
		ASTPair currentAST = new ASTPair();
		AST term_AST = null;
		
		try {      // for error handling
			switch ( LA(1)) {
			case NCName:
			case QNAME:
			{
				uriReference();
				astFactory.addASTChild(currentAST, returnAST);
				term_AST = (AST)currentAST.root;
				break;
			}
			case VARIABLE:
			{
				AST tmp74_AST = null;
				tmp74_AST = astFactory.create(LT(1));
				astFactory.addASTChild(currentAST, tmp74_AST);
				match(VARIABLE);
				term_AST = (AST)currentAST.root;
				break;
			}
			default:
			{
				throw new NoViableAltException(LT(1), getFilename());
			}
			}
		}
		catch (RecognitionException ex) {
			if (inputState.guessing==0) {
				reportError(ex);
				recover(ex,_tokenSet_0);
			} else {
			  throw ex;
			}
		}
		returnAST = term_AST;
	}
	
	
	public static final String[] _tokenNames = {
		"<0>",
		"EOF",
		"<2>",
		"NULL_TREE_LOOKAHEAD",
		"SEMICOLON",
		"\"ns\"",
		"LPAREN",
		"PREFIX",
		"COLON",
		"NCName",
		"RPAREN",
		"\"U\"",
		"\"B\"",
		"\"X\"",
		"\"F\"",
		"\"G\"",
		"\"not\"",
		"IMPLIES_ROLE",
		"COMMA",
		"EQUALS",
		"IMPLIES",
		"\"transitive\"",
		"DOUBLE_EQUAL",
		"\"and\"",
		"\"or\"",
		"BAR",
		"AMP",
		"TILDE",
		"\"some\"",
		"\"all\"",
		"GREATER_THAN_OR_EQ",
		"LESS_THAN_OR_EQ",
		"LBRACE",
		"RBRACE",
		"DASH",
		"VARIABLE",
		"QNAME",
		"UNSIGNED_INT",
		"WORLD",
		"CONCEPT_ASSERTION",
		"OBJECT_ROLE_ASSERTION",
		"CARET",
		"STRING_LITERAL",
		"UNDERSCORE",
		"CHAR_ESC",
		"PREFIX_LOCALNAME_OR_QNAME",
		"LOCAL_NAME",
		"NCBegin",
		"NCRest",
		"GREATER_THAN",
		"LESS_THAN",
		"HASH",
		"SLASH",
		"QUESTION",
		"LOWER_CASE_LETTER",
		"UPPER_CASE_LETTER",
		"LETTER",
		"DIGIT",
		"ALPHANUMERIC",
		"POINT",
		"LBRACKET",
		"RBRACKET",
		"WS"
	};
	
	protected void buildTokenTypeASTClassMap() {
		tokenTypeToASTClassMap=null;
	};
	
	private static final long[] mk_tokenSet_0() {
		long[] data = { 2L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_0 = new BitSet(mk_tokenSet_0());
	private static final long[] mk_tokenSet_1() {
		long[] data = { 94382449216L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_1 = new BitSet(mk_tokenSet_1());
	private static final long[] mk_tokenSet_2() {
		long[] data = { 77281819200L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_2 = new BitSet(mk_tokenSet_2());
	private static final long[] mk_tokenSet_3() {
		long[] data = { 240513580608L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_3 = new BitSet(mk_tokenSet_3());
	private static final long[] mk_tokenSet_4() {
		long[] data = { 240518168128L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_4 = new BitSet(mk_tokenSet_4());
	private static final long[] mk_tokenSet_5() {
		long[] data = { 240518168146L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_5 = new BitSet(mk_tokenSet_5());
	private static final long[] mk_tokenSet_6() {
		long[] data = { 263186L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_6 = new BitSet(mk_tokenSet_6());
	private static final long[] mk_tokenSet_7() {
		long[] data = { 16L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_7 = new BitSet(mk_tokenSet_7());
	private static final long[] mk_tokenSet_8() {
		long[] data = { 94489016896L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_8 = new BitSet(mk_tokenSet_8());
	private static final long[] mk_tokenSet_9() {
		long[] data = { 240517905984L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_9 = new BitSet(mk_tokenSet_9());
	private static final long[] mk_tokenSet_10() {
		long[] data = { 94357217856L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_10 = new BitSet(mk_tokenSet_10());
	private static final long[] mk_tokenSet_11() {
		long[] data = { 240486252096L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_11 = new BitSet(mk_tokenSet_11());
	private static final long[] mk_tokenSet_12() {
		long[] data = { 240486514258L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_12 = new BitSet(mk_tokenSet_12());
	private static final long[] mk_tokenSet_13() {
		long[] data = { 240513973842L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_13 = new BitSet(mk_tokenSet_13());
	private static final long[] mk_tokenSet_14() {
		long[] data = { 263250L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_14 = new BitSet(mk_tokenSet_14());
	private static final long[] mk_tokenSet_15() {
		long[] data = { 94382849618L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_15 = new BitSet(mk_tokenSet_15());
	private static final long[] mk_tokenSet_16() {
		long[] data = { 77175251520L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_16 = new BitSet(mk_tokenSet_16());
	private static final long[] mk_tokenSet_17() {
		long[] data = { 77277493824L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_17 = new BitSet(mk_tokenSet_17());
	private static final long[] mk_tokenSet_18() {
		long[] data = { 240513842770L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_18 = new BitSet(mk_tokenSet_18());
	private static final long[] mk_tokenSet_19() {
		long[] data = { 77275920960L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_19 = new BitSet(mk_tokenSet_19());
	private static final long[] mk_tokenSet_20() {
		long[] data = { 240484679232L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_20 = new BitSet(mk_tokenSet_20());
	private static final long[] mk_tokenSet_21() {
		long[] data = { 240484941376L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_21 = new BitSet(mk_tokenSet_21());
	private static final long[] mk_tokenSet_22() {
		long[] data = { 240484941394L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_22 = new BitSet(mk_tokenSet_22());
	private static final long[] mk_tokenSet_23() {
		long[] data = { 394322L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_23 = new BitSet(mk_tokenSet_23());
	private static final long[] mk_tokenSet_24() {
		long[] data = { 8696765522L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_24 = new BitSet(mk_tokenSet_24());
	private static final long[] mk_tokenSet_25() {
		long[] data = { 1836114L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_25 = new BitSet(mk_tokenSet_25());
	private static final long[] mk_tokenSet_26() {
		long[] data = { 1024L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_26 = new BitSet(mk_tokenSet_26());
	private static final long[] mk_tokenSet_27() {
		long[] data = { 35396690L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_27 = new BitSet(mk_tokenSet_27());
	private static final long[] mk_tokenSet_28() {
		long[] data = { 102505554L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_28 = new BitSet(mk_tokenSet_28());
	private static final long[] mk_tokenSet_29() {
		long[] data = { 262144L, 0L};
		return data;
	}
	public static final BitSet _tokenSet_29 = new BitSet(mk_tokenSet_29());
	
	}
